home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / makeindex / scanst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-26  |  12.1 KB  |  536 lines
  1. /*
  2.  *
  3.  * Copyright (C) 1987     Pehong Chen    (phc@renoir.berkeley.edu)
  4.  * Computer Science Division
  5.  * University of California, Berkeley
  6.  *
  7.  */
  8.  
  9. #include    "mkind.h"
  10. #include    "scanst.h"
  11.  
  12. static int        sty_lc = 0;    /* line count */
  13. static int        sty_tc = 0;    /* total count */
  14. static int        sty_ec = 0;    /* error count */
  15.  
  16. char    idx_keyword[LONG_MAX]   = IDX_KEYWORD;
  17. char    idx_aopen          = IDX_AOPEN;
  18. char    idx_aclose          = IDX_ACLOSE;
  19. char    idx_level          = IDX_LEVEL;
  20. char    idx_ropen          = IDX_ROPEN;
  21. char    idx_rclose          = IDX_RCLOSE;
  22. char    idx_quote          = IDX_QUOTE;
  23. char    idx_actual          = IDX_ACTUAL;
  24. char    idx_encap          = IDX_ENCAP;
  25. char    idx_escape          = IDX_ESCAPE;
  26.  
  27. char    preamble[LONG_MAX]  = PREAMBLE_DEF;
  28. char    postamble[LONG_MAX] = POSTAMBLE_DEF;
  29. int    prelen  = PREAMBLE_LEN;
  30. int    postlen = POSTAMBLE_LEN;
  31.  
  32. char    setpage_open[LONG_MAX] = SETPAGEOPEN_DEF;
  33. char    setpage_close[LONG_MAX] = SETPAGECLOSE_DEF;
  34. int    setpagelen = SETPAGE_LEN;
  35.  
  36. char    group_skip[LONG_MAX]    = GROUPSKIP_DEF;
  37. char    lethead_pre[LONG_MAX]    = LETHEADPRE_DEF;
  38. char    lethead_suf[LONG_MAX]    = LETHEADSUF_DEF;
  39. int    lethead_flag = LETHEADFLAG_DEF;
  40. int    skiplen = GROUPSKIP_LEN;
  41. int    headprelen = LETHEADPRE_LEN;
  42. int    headsuflen = LETHEADSUF_LEN;
  43.  
  44. char    item_r[FIELD_MAX][LONG_MAX] = {ITEM0_DEF, ITEM1_DEF, ITEM2_DEF};
  45. char    item_u[FIELD_MAX][LONG_MAX] = {"", ITEM1_DEF, ITEM2_DEF};
  46. char    item_x[FIELD_MAX][LONG_MAX] = {"", ITEM1_DEF, ITEM2_DEF};
  47. int    ilen_r[FIELD_MAX] = {ITEM_LEN, ITEM_LEN, ITEM_LEN};
  48. int    ilen_u[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN};
  49. int    ilen_x[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN};
  50.  
  51. char    delim_p[FIELD_MAX][LONG_MAX] = {DELIM_DEF, DELIM_DEF, DELIM_DEF};
  52. char    delim_n[LONG_MAX] = DELIM_DEF;   /* page number separator */
  53. char    delim_r[LONG_MAX] = DELIMR_DEF;  /* page range designator */
  54.  
  55. char    encap_p[LONG_MAX] = ENCAP0_DEF;    /* encapsulator prefix */
  56. char    encap_i[LONG_MAX] = ENCAP1_DEF;    /* encapsulator infix */
  57. char    encap_s[LONG_MAX] = ENCAP2_DEF;    /* encapsulator postfix */
  58.  
  59. int    linemax = LINE_MAX;
  60. int    indent_length = INDENTLEN_DEF;
  61. char    indent_space[LONG_MAX] = INDENTSPC_DEF;
  62.  
  63. char    page_comp[LONG_MAX] = COMPOSITOR_DEF;
  64. int    page_offset[PAGETYPE_MAX] = {
  65.     0,
  66.     ROMAN_LOWER_OFFSET,
  67.     ROMAN_LOWER_OFFSET + ARABIC_OFFSET,
  68.     ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET,
  69.     ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET + ROMAN_UPPER_OFFSET
  70.     };
  71. static char    page_prec[LONG_MAX] = PRECEDENCE_DEF;
  72.  
  73. static    int        put_dot;
  74.  
  75. void
  76. scan_sty()
  77. {
  78.     char        spec[STRING_MAX];
  79.     int        tmp;
  80.  
  81.     MESSAGE("Scanning style file %s", sty_fn);
  82.     while (scan_spec(spec)) {
  83.         sty_tc++;
  84.         put_dot = TRUE;
  85.  
  86.         /* output pre- and post-ambles */
  87.         if (STREQ(spec, PREAMBLE)) {
  88.             (void)scan_string(preamble);
  89.             prelen = count_lfd(preamble);
  90.         } else if (STREQ(spec, POSTAMBLE)) {
  91.             (void)scan_string(postamble);
  92.             postlen = count_lfd(postamble);
  93.         } else if (STREQ(spec, GROUP_SKIP)) {
  94.             (void)scan_string(group_skip);
  95.             skiplen = count_lfd(group_skip);
  96.         } else if (STREQ(spec, LETHEAD_PRE)) {
  97.             (void)scan_string(lethead_pre);
  98.             headprelen = count_lfd(lethead_pre);
  99.         } else if (STREQ(spec, LETHEAD_SUF)) {
  100.             (void)scan_string(lethead_suf);
  101.             headsuflen = count_lfd(lethead_suf);
  102.         } else if (STREQ(spec, LETHEAD_FLAG)) {
  103.             SCAN_NO(&lethead_flag);
  104.         } else if (STREQ(spec, SETPAGEOPEN)) {
  105.             (void)scan_string(setpage_open);
  106.             setpagelen = count_lfd(setpage_open);
  107.         } else if (STREQ(spec, SETPAGECLOSE)) {
  108.             (void)scan_string(setpage_close);
  109.             setpagelen = count_lfd(setpage_close);
  110.         /* output index item commands */
  111.         } else if (STREQ(spec, ITEM_0)) {
  112.             (void)scan_string(item_r[0]);
  113.             ilen_r[0] = count_lfd(item_r[0]);
  114.         } else if (STREQ(spec, ITEM_1)) {
  115.             (void)scan_string(item_r[1]);
  116.             ilen_r[1] = count_lfd(item_r[1]);
  117.         } else if (STREQ(spec, ITEM_2)) {
  118.             (void)scan_string(item_r[2]);
  119.             ilen_r[2] = count_lfd(item_r[2]);
  120.         } else if (STREQ(spec, ITEM_01)) {
  121.             (void)scan_string(item_u[1]);
  122.             ilen_u[1] = count_lfd(item_u[1]);
  123.         } else if (STREQ(spec, ITEM_12)) {
  124.             (void)scan_string(item_u[2]);
  125.             ilen_u[2] = count_lfd(item_u[2]);
  126.         } else if (STREQ(spec, ITEM_x1)) {
  127.             (void)scan_string(item_x[1]);
  128.             ilen_x[1] = count_lfd(item_x[1]);
  129.         } else if (STREQ(spec, ITEM_x2)) {
  130.             (void)scan_string(item_x[2]);
  131.             ilen_x[2] = count_lfd(item_x[2]);
  132.         /* output encapsulators */
  133.         } else if (STREQ(spec, ENCAP_0))
  134.             (void)scan_string(encap_p);
  135.         else if (STREQ(spec, ENCAP_1))
  136.             (void)scan_string(encap_i);
  137.         else if (STREQ(spec, ENCAP_2))
  138.             (void)scan_string(encap_s);
  139.         /* output delimiters */
  140.         else if (STREQ(spec, DELIM_0))
  141.             (void)scan_string(delim_p[0]);
  142.         else if (STREQ(spec, DELIM_1))
  143.             (void)scan_string(delim_p[1]);
  144.         else if (STREQ(spec, DELIM_2))
  145.             (void)scan_string(delim_p[2]);
  146.         else if (STREQ(spec, DELIM_N))
  147.             (void)scan_string(delim_n);
  148.         else if (STREQ(spec, DELIM_R))
  149.             (void)scan_string(delim_r);
  150.         /* output line width */
  151.         else if (STREQ(spec, LINEMAX)) {
  152.             SCAN_NO(&tmp);
  153.             if (tmp > 0)
  154.                 linemax = tmp;
  155.             else
  156.                 STY_ERROR2("%s must be positive (got %d)", LINE_MAX, tmp);
  157.         /* output line indentation length*/
  158.         } else if (STREQ(spec, INDENT_LENGTH)) {
  159.             SCAN_NO(&tmp);
  160.             if (tmp >= 0)
  161.                 indent_length = tmp;
  162.             else
  163.                 STY_ERROR2("%s must be nonnegative (got %d)", INDENT_LENGTH, tmp);
  164.         /* output line indentation*/
  165.         } else if (STREQ(spec, INDENT_SPACE)) {
  166.             (void)scan_string(indent_space);
  167.         /* composite page delimiter */
  168.         } else if (STREQ(spec, COMPOSITOR)) {
  169.             (void)scan_string(page_comp);
  170.         /* page precedence */
  171.         } else if (STREQ(spec, PRECEDENCE)) {
  172.             (void)scan_string(page_prec);
  173.             (void)process_precedence();
  174.         /* index input format */
  175.         } else if (STREQ(spec, KEYWORD))
  176.             (void)scan_string(idx_keyword);
  177.         else if (STREQ(spec, AOPEN))
  178.             (void)scan_char(&idx_aopen);
  179.         else if (STREQ(spec, ACLOSE))
  180.             (void)scan_char(&idx_aclose);
  181.         else if (STREQ(spec, LEVEL))
  182.             (void)scan_char(&idx_level);
  183.         else if (STREQ(spec, ROPEN))
  184.             (void)scan_char(&idx_ropen);
  185.         else if (STREQ(spec, RCLOSE))
  186.             (void)scan_char(&idx_rclose);
  187.         else if (STREQ(spec, QUOTE))
  188.             (void)scan_char(&idx_quote);
  189.         else if (STREQ(spec, ACTUAL))
  190.             (void)scan_char(&idx_actual);
  191.         else if (STREQ(spec, ENCAP))
  192.             (void)scan_char(&idx_encap);
  193.         else if (STREQ(spec, ESCAPE))
  194.             (void)scan_char(&idx_escape);
  195.         else {
  196.             (void)next_nonblank();
  197.             STY_SKIPLINE;
  198.             STY_ERROR("Unknown specifier %s.\n", spec);
  199.             put_dot = FALSE;
  200.         }
  201.         if (put_dot) {
  202.             STY_DOT;
  203.         }
  204.     }
  205.  
  206.     /* check if quote and escape are distinct */
  207.     if (idx_quote == idx_escape) {
  208.         STY_ERROR("Quote and escape symbols must be distinct (both `%c' now).\n", idx_quote);
  209.         idx_quote = IDX_QUOTE;
  210.         idx_escape = IDX_ESCAPE;
  211.     }
  212.  
  213.     DONE(sty_tc - sty_ec, "attributes redefined", sty_ec, "ignored");
  214.     CLOSE(sty_fp);
  215. }
  216.  
  217.  
  218. static int
  219. scan_spec(spec)
  220.     char    spec[];
  221. {
  222.     int    i = 0;
  223.     int    c;
  224.  
  225.     while (TRUE)
  226.         if ((c = next_nonblank()) == -1)
  227.             return (FALSE);
  228.         else if (c == COMMENT) {
  229.             STY_SKIPLINE;
  230.         } else
  231.             break;
  232.  
  233.     spec[0] = TOLOWER(c);
  234.     while ((i++ < STRING_MAX) && ((c = GET_CHAR(sty_fp)) != SPC) &&
  235.            (c != TAB) && (c != LFD) && (c != EOF))
  236.         spec[i] = TOLOWER(c);
  237.     if (i < STRING_MAX) {
  238.         spec[i] = NULL;
  239.         if (c == EOF) {
  240.             STY_ERROR("No attribute for specifier %s (premature EOF)\n", spec);
  241.             return(-1);
  242.         }
  243.         if (c == LFD)
  244.             sty_lc++;
  245.         return (TRUE);
  246.     } else {
  247.         STY_ERROR2("Specifier %s too long (max %d).\n", spec, STRING_MAX);
  248.         return(FALSE);
  249.     }
  250. }
  251.  
  252.  
  253. static int
  254. next_nonblank()
  255. {
  256.     int    c;
  257.  
  258.     while (TRUE) {
  259.         switch (c = GET_CHAR(sty_fp)) {
  260.         case EOF:
  261.             return (-1);
  262.  
  263.         case LFD:
  264.             sty_lc++;
  265.         case SPC:
  266.         case TAB:
  267.             break;
  268.         default:
  269.             return (c);
  270.         }
  271.     }
  272. }
  273.  
  274.  
  275. static int
  276. scan_string(str)
  277.     char    str[];
  278. {
  279.     char    clone[LONG_MAX];
  280.     int    i = 0;
  281.     int    c;
  282.  
  283.     switch (c = next_nonblank()) {
  284.     case STR_DELIM:
  285.         while (TRUE)
  286.             switch (c = GET_CHAR(sty_fp)) {
  287.             case EOF:
  288.                 STY_ERROR("No closing delimiter in %s.\n", clone);
  289.                 return (FALSE);
  290.             case STR_DELIM:
  291.                 clone[i] = NULL;
  292.                 strcpy(str, clone);
  293.                 return (TRUE);
  294.             case BSH:
  295.                 switch (c = GET_CHAR(sty_fp)) {
  296.                 case 't':
  297.                     clone[i++] = TAB;
  298.                     break;
  299.                 case 'n':
  300.                     clone[i++] = LFD;
  301.                     break;
  302.  
  303.                 default:
  304.                     clone[i++] = (char)c;
  305.                     break;
  306.                 }
  307.                 break;
  308.             default:
  309.                 if (c == LFD)
  310.                     sty_lc++;
  311.                 if (i < LONG_MAX)
  312.                     clone[i++] = (char)c;
  313.                 else {
  314.                     STY_SKIPLINE;
  315.                     STY_ERROR2("Attribute string %s too long (max %d).\n",
  316.                           clone, LONG_MAX);
  317.                     return (FALSE);
  318.                 }
  319.                 break;
  320.             }
  321.         break;
  322.     case COMMENT:
  323.         STY_SKIPLINE;
  324.         break;
  325.     default:
  326.         STY_SKIPLINE;
  327.         STY_ERROR("No opening delimiter.\n", "");
  328.         return (FALSE);
  329.     }
  330.     return (TRUE);        /* function value no longer used */
  331. }
  332.  
  333.  
  334. static int
  335. scan_char(c)
  336.     char    *c;
  337. {
  338.     int    clone;
  339.  
  340.     switch (clone = next_nonblank()) {
  341.     case CHR_DELIM:
  342.         switch (clone = GET_CHAR(sty_fp)) {
  343.         case CHR_DELIM:
  344.             STY_SKIPLINE;
  345.             STY_ERROR("Premature closing delimiter.\n", "");
  346.             return (FALSE);
  347.         case LFD:
  348.             sty_lc++;
  349.         case EOF:
  350.             STY_ERROR("No character (premature EOF).\n", "");
  351.             return (FALSE);
  352.         case BSH:
  353.             clone = GET_CHAR(sty_fp);
  354.         default:
  355.             if (GET_CHAR(sty_fp) == CHR_DELIM) {
  356.                 *c = (char)clone;
  357.                 return (TRUE);
  358.             } else {
  359.                 STY_ERROR("No closing delimiter or too many letters.\n", "");
  360.                 return (FALSE);
  361.             }
  362.             break;
  363.         }
  364.         break;
  365.     case COMMENT:
  366.         STY_SKIPLINE;
  367.         break;
  368.     default:
  369.         STY_SKIPLINE;
  370.         STY_ERROR("No opening delimiter.\n", "");
  371.         return (FALSE);
  372.     }
  373.     return (TRUE);        /* function value no longer used */
  374. }
  375.  
  376.  
  377. static int
  378. count_lfd(str)
  379.     char        *str;
  380. {
  381.     int        i = 0;
  382.     int        n = 0;
  383.  
  384.     while (str[i] != NULL) {
  385.         if (str[i] == LFD)
  386.             n++;
  387.         i++;
  388.     }
  389.     return (n);
  390. }
  391.  
  392.  
  393. static int
  394. process_precedence()
  395. {
  396.     int        order[PAGETYPE_MAX];
  397.     int        type[PAGETYPE_MAX];
  398.     int        i = 0;
  399.     int        last;
  400.     int        roml = FALSE;
  401.     int        romu = FALSE;
  402.     int        arab = FALSE;
  403.     int        alpl = FALSE;
  404.     int        alpu = FALSE;
  405.  
  406.     /* check for llegal specifiers first */
  407.     while ((i < PAGETYPE_MAX) && (page_prec[i] != NULL)) {
  408.         switch (page_prec[i]) {
  409.         case ROMAN_LOWER:
  410.             if (roml) {
  411.                 MULTIPLE(ROMAN_LOWER);
  412.             } else
  413.                 roml = TRUE;
  414.             break;
  415.         case ROMAN_UPPER:
  416.             if (romu) {
  417.                 MULTIPLE(ROMAN_UPPER);
  418.             } else
  419.                 romu = TRUE;
  420.             break;
  421.         case ARABIC:
  422.             if (arab) {
  423.                 MULTIPLE(ARABIC);
  424.             } else
  425.                 arab = TRUE;
  426.             break;
  427.         case ALPHA_LOWER:
  428.             if (alpl) {
  429.                 MULTIPLE(ALPHA_UPPER);
  430.             } else
  431.                 alpl = TRUE;
  432.             break;
  433.         case ALPHA_UPPER:
  434.             if (alpu) {
  435.                 MULTIPLE(ALPHA_UPPER);
  436.             } else
  437.                 alpu = TRUE;
  438.             break;
  439.         default:
  440.             STY_SKIPLINE;
  441.             STY_ERROR("Unknow type `%c' in page precedence specification.\n", page_prec[i]);
  442.             return (FALSE);
  443.         }
  444.         i++;
  445.     }
  446.     if (page_prec[i] != NULL) {
  447.         STY_SKIPLINE;
  448.         STY_ERROR("Page precedence specification string too long.\n", "");
  449.         return (FALSE);
  450.     }
  451.  
  452.     last = i;
  453.     switch (page_prec[0]) {
  454.     case ROMAN_LOWER:
  455.         order[0] = ROMAN_LOWER_OFFSET;
  456.         type[0] = ROML;
  457.         break;
  458.     case ROMAN_UPPER:
  459.         order[0] = ROMAN_UPPER_OFFSET;
  460.         type[0] = ROMU;
  461.         break;
  462.     case ARABIC:
  463.         order[0] = ARABIC_OFFSET;
  464.         type[0] = ARAB;
  465.         break;
  466.     case ALPHA_LOWER:
  467.         order[0] = ALPHA_LOWER_OFFSET;
  468.         type[0] = ALPL;
  469.         break;
  470.     case ALPHA_UPPER:
  471.         order[0] = ALPHA_LOWER_OFFSET;
  472.         type[0] = ALPU;
  473.         break;
  474.     }
  475.  
  476.     i = 1;
  477.     while (i < last) {
  478.         switch (page_prec[i]) {
  479.         case ROMAN_LOWER:
  480.             order[i] = order[i-1] + ROMAN_LOWER_OFFSET;
  481.             type[i] = ROML;
  482.             break;
  483.         case ROMAN_UPPER:
  484.             order[i] = order[i-1] + ROMAN_UPPER_OFFSET;
  485.             type[i] = ROMU;
  486.             break;
  487.         case ARABIC:
  488.             order[i] = order[i-1] + ARABIC_OFFSET;
  489.             type[i] = ARAB;
  490.             break;
  491.         case ALPHA_LOWER:
  492.             order[i] = order[i-1] + ALPHA_LOWER_OFFSET;
  493.             type[i] = ALPL;
  494.             break;
  495.         case ALPHA_UPPER:
  496.             order[i] = order[i-1] + ALPHA_LOWER_OFFSET;
  497.             type[i] = ALPU;
  498.             break;
  499.         }
  500.         i++;
  501.     }
  502.  
  503.     for (i = 0; i < PAGETYPE_MAX; i++) {
  504.         page_offset[i] = -1;
  505.     }
  506.     page_offset[type[0]] = 0;
  507.     for (i = 1; i < last; i++) {
  508.         page_offset[type[i]] = order[i-1];
  509.     }
  510.     for (i = 0; i < PAGETYPE_MAX; i++) {
  511.         if (page_offset[i] == -1) {
  512.             switch (type[last-1]) {
  513.             case ROML:
  514.                 order[last] = order[last-1] + ROMAN_LOWER_OFFSET;
  515.                 break;
  516.             case ROMU:
  517.                 order[last] = order[last-1] + ROMAN_UPPER_OFFSET;
  518.                 break;
  519.             case ARAB:
  520.                 order[last] = order[last-1] + ARABIC_OFFSET;
  521.                 break;
  522.             case ALPL:
  523.                 order[last] = order[last-1] + ALPHA_LOWER_OFFSET;
  524.                 break;
  525.             case ALPU:
  526.                 order[last] = order[last-1] + ALPHA_UPPER_OFFSET;
  527.                 break;
  528.             }
  529.             type[last] = i;
  530.             page_offset[i] = order[last];
  531.             last++;
  532.         }
  533.     }
  534.     return (TRUE);        /* function value no longer used */
  535. }
  536.